RED = "\033[31m"
GREEN = "\033[32m"
YELLOW = "\033[33m"
BLUE = "\033[34m"
RESET = "\033[0m"  # сброс цветов до стандартных

# !pip install torch==1.12.1+cu116 torchvision==0.13.1+cu116 --index-url https://download.pytorch.org/whl/cu116
# !pip install tensorboard==2.10.1 tensorflow==2.10.0
# !pip install pydantic==2.10.3
# !pip install tqdm==4.66.2
# !pip install scikit-learn==1.5.1
# !pip install scipy==1.13.1
# !pip install seaborn==0.13.2
# !pip install rich==13.7.1
# !pip install requests==2.32.3
# !pip install pillow==10.4.0
# !pip install pandas==2.2.2
# !pip install matplotlib==3.9.2
# !pip install duckdb==1.1.0
# !pip install annotated-types==0.7.0

print(f"{YELLOW}"+60*"-"+f"{RESET}")
print(f"Библиотеки: \n")

# Дополнительные библиотеки
import platform # Узнать версию пайтона ;)
import os
import logging
import time
import sys
import random
import re
import shutil
from tqdm import tqdm
from functools import wraps
from typing import Any, Tuple, Union, Optional, List, Type, Callable, Dict
from collections import Counter
import zipfile
from dataclasses import dataclass

# Основные библиотеки
import IPython.display as ipd # Добавляет виджеты для ячеек юпитера
from IPython import get_ipython
import ipykernel
print(f"python: {BLUE}{platform.python_version()}{RESET} ")
import matplotlib # Для рисунков
import matplotlib.pyplot as plt
print(f"matplotlib: {BLUE}{matplotlib.__version__}{RESET}")
import numpy as np # Для работы с массивами
print(f"numpy: {BLUE}{np.__version__}{RESET}")
import pandas as pd # Работа с таблицами
print(f"pandas: {BLUE}{pd.__version__}{RESET}")
import sklearn # Много полезного для ML
from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score
print(f"sklearn: {BLUE}{sklearn.__version__}{RESET}")
import scipy
print(f"scipy: {BLUE}{scipy.__version__}{RESET}")
import pydantic # Для валидации данных
from pydantic import (BaseModel, Field, StrictStr, condecimal, StrictInt, StrictBool,
                      FilePath, DirectoryPath, ValidationError, root_validator, ConfigDict)
print(f"pydantic: {BLUE}{pydantic.__version__}{RESET}")
import fastapi
from fastapi import HTTPException, status
print(f"fastapi: {BLUE}{fastapi.__version__}{RESET}")
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torch.utils.data import DataLoader, Subset, WeightedRandomSampler
print(f"torch: {BLUE}{torch.__version__}{RESET}")
import torchvision
from torchvision import datasets
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder
import torchvision.models as models
print(f"torchvision: {BLUE}{torchvision.__version__}{RESET}")
import requests
print(f"requests: {BLUE}{requests.__version__}{RESET}")
import PIL
from PIL import Image
print(f"Pillow: {BLUE}{PIL.__version__}{RESET}")

from rich.theme import Theme
from rich.logging import RichHandler
from rich.console import Console
from rich.pretty import install as pretty_install
from rich.traceback import install as traceback_install


print(f"{YELLOW}"+60*"-"+f"{RESET}")

------------------------------------------------------------
Библиотеки: 

python: 3.9.16 
matplotlib: 3.9.2
numpy: 1.26.4
pandas: 2.2.2
sklearn: 1.5.1
scipy: 1.13.1
pydantic: 2.10.3
fastapi: 0.115.7

C:\Users\NightMare\PycharmProjects\CVtools\venv\lib\site-packages\tqdm\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm

torch: 1.12.1+cu116
torchvision: 0.13.1+cu116
requests: 2.32.3
Pillow: 10.4.0
------------------------------------------------------------

import warnings
warnings.filterwarnings("ignore")
import logging
# Отключение логирования для cmdstanpy
logging.getLogger('cmdstanpy').setLevel(logging.ERROR)
# Полезна при разработке собственных библиотек, юпитер будет переимпортировать модули, если в них были изменения
%load_ext autoreload
%autoreload 1

log = None

def setup_logging(clean=False, debug=False):
    global log

    if log is not None:
        return log

    try:
        if clean and os.path.isfile('setup.log'):
            os.remove('setup.log')
        time.sleep(0.1)  # prevent race condition
    except:
        pass

    if sys.version_info >= (3, 9):
        logging.basicConfig(level=logging.DEBUG, format='%(asctime)s | %(levelname)s | %(pathname)s | %(message)s',
                            filename='setup.log', filemode='a', encoding='utf-8', force=True)
    else:
        logging.basicConfig(level=logging.DEBUG, format='%(asctime)s | %(levelname)s | %(pathname)s | %(message)s',
                            filename='setup.log', filemode='a', force=True)

    console = Console(log_time=True, log_time_format='%H:%M:%S-%f', theme=Theme({
        "traceback.border": "black",
        "traceback.border.syntax_error": "black",
        "inspect.value.border": "black",
    }))
    pretty_install(console=console)
    traceback_install(console=console, extra_lines=1, width=console.width, word_wrap=False, indent_guides=False,
                      suppress=[])
    rh = RichHandler(show_time=True, omit_repeated_times=False, show_level=True, show_path=False, markup=False,
                     rich_tracebacks=True, log_time_format='%H:%M:%S-%f',
                     level=logging.DEBUG if debug else logging.INFO, console=console)
    rh.set_name(logging.DEBUG if debug else logging.INFO)
    log = logging.getLogger("sd")
    log.addHandler(rh)

    return log

log = setup_logging()

def validate_with_pydantic(model_cls):
    """
    Декоратор для валидации данных с использованием Pydantic-модели.
    """

    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Проверяем данные в аргументах функции
            try:
                data = kwargs.get("entry", args[0] if args else None)
                if not data:
                    raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
                                        detail="No data provided for validation.")
                # Валидация данных
                if isinstance(data, BaseModel):
                    data = data.dict(by_alias=True)
                validated_data = model_cls(**data)
                # Передаем валидированные данные дальше
                kwargs["entry"] = validated_data
                return func(*args, **kwargs)
            except ValidationError as ve:
                log.exception("Validation failed", exc_info=ve)
                raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
                                    detail="Invalid data for Pydantic model.") from ve

        return wrapper

    return decorator

def auto_generate_docstring(cls: Type[BaseModel]) -> Type[BaseModel]:
    """
    Декоратор для автоматического добавления docstring в классы Pydantic.
    """

    def generate_docstring(model: Type[BaseModel]) -> str:
        """
        Генерация строки документации из описания полей модели Pydantic.
        """
        docstring = []
        for field_name, field_info in model.__fields__.items():
            field_details = f"Field '{field_name}':\n"
            if field_info.description:  # Получение описания
                field_details += f"  Description: {field_info.description}\n"
            if field_info.examples:  # Получение примеров
                field_details += f"  Examples: {field_info.examples}\n"
            docstring.append(field_details)
        return "\n".join(docstring)

    # Добавляем описание к существующему docstring
    cls.__doc__ = (cls.__doc__ or "") + "\n\n" + generate_docstring(cls)
    return cls

@auto_generate_docstring
class EntryGraduateModel(BaseModel):
    """
    Класс для валидации входных данных EntryGraduateModel
    """
    model_config = ConfigDict(arbitrary_types_allowed=True)
    Prefix: Optional[StrictStr] = Field("",
                                        alias="prefix",
                                        examples=["exp1"],
                                        descripton="Префикс к названию модели")
    Models: list[str] = Field(...,
                              alias="models",
                              examples=[["efficientnet_b0", "efficientnet_b1"]],
                              description="Список моделей для обучения")
    NameOptimizers: list[str] = Field(...,
                                      alias="name_optimizers",
                                      examples=[["Adam"]],
                                      description="Лист с названиями оптимизаторов из доступных в torch.nn.optim для каждой модели")
    UseImageNetWeights: Optional[bool] = Field(False,
                                               alias="is_use_imagenet_weights",
                                               examples=[True],
                                               description="Использовать предобученные веса ImageNet?")
    IsGray: Optional[bool] = Field(False,
                                   alias="is_gray",
                                   examples=[False],
                                   description="RGB в GrayScale?")
    NameLoss: Optional[StrictStr] = Field("CrossEntropyLoss",
                                          alias="name_loss",
                                          examples=["name_loss"],
                                          description="Название функции потерь из torch.utils")
    SizeImg: Optional[tuple] = Field((64, 64),
                                     alias="size_img",
                                     examples=[(224, 224)],
                                     description="Размер изображения для обучения")
    Ratio: Optional[tuple] = Field((60, 20, 20),
                                   alias="ratio",
                                   examples=[(60, 20, 20)],
                                   description="Доля тренировочной, валидационной и тестовой выборок")
    PathData: Optional[StrictStr] = Field("./data",
                                          alias="path_to_data",
                                          examples=["./data"],
                                          description="Путь к директории с данными. Дефолтный путь ./data")
    PathWeights: Optional[StrictStr] = Field("./weights",
                                             alias="path_to_weights",
                                             examples=["./weights"],
                                             description="Если сохраняем веса, то куда? Дефолтный путь ./weights")
    PathMetricsTrain: Optional[StrictStr] = Field("./metrics_train",
                                                  alias="path_to_metrics_train",
                                                  examples=["./metrics_train"],
                                                  description="Куда сохраняем тренировочные метрики? Дефолтный путь ./metrics_train")
    PathMetricsTest: Optional[StrictStr] = Field("./metrics_test",
                                                 alias="path_to_metrics_test",
                                                 examples=["./metrics_test"],
                                                 description="Куда сохраняем тестовые метрики? Дефолтный путь ./metrics_test")
    PathSavePlots: Optional[StrictStr] = Field("./plot",
                                               alias="path_to_save_plots",
                                               examples=["./plot"],
                                               description="Куда сохраняем графики результатов обучения? Дефолтный путь ./plot")
    UseDevice: Optional[StrictStr] = Field(None,
                                           alias="use_device",
                                           examples=["cuda"],
                                           description="Какое устройство использовать? cpu/cuda")
    StartLerningRate: Optional[condecimal(ge=0.00000001, le=0.01, decimal_places=8)] = Field(0.0001,
                                                                                             alias="start_learning_rate",
                                                                                             examples=[0.0001],
                                                                                             description="Начальная величина шага градиентного спуска")
    BatchSize: Optional[StrictInt] = Field(1,
                                           alias="batch_size",
                                           examples=[10],
                                           description="Размер пакета при обучении")
    NumWorkers: Optional[StrictInt] = Field(0,
                                            alias="num_workers",
                                            examples=[0],
                                            description="Кол. используемых потоков при подгрузке данных DataLoader (0 это 1)")
    PinMemory: Optional[StrictBool] = Field(False,
                                            alias="pin_memory",
                                            examples=[False],
                                            description="Если True ускоряет загрузку данных на видеокарте, для cpu всегда False")
    NumEpochs: Optional[StrictInt] = Field(3,
                                           alias="num_epochs",
                                           examples=[20],
                                           description="Количество эпох обучения для каждой модели")
    Seed: Optional[StrictInt] = Field(17,
                                      alias="seed",
                                      examples=[17],
                                      description="Сажает зерно")
    ClassPercentages: Optional[dict[str, int]] = Field(None,
                                                       alias="class_persantages",
                                                       examples=[{"cats": 0.2, "dogs": 0.4}],
                                                       description="Доля используемых данных в обучении для каждого класса")
    UseClassWeights: Optional[bool] = Field(False,
                                            alias="is_use_class_weights",
                                            examples=[True],
                                            description="Учитывать ли веса классов в функции потерь?")
    ResamplingMethod: Optional[str] = Field(None,
                                            alias="resampling_method",
                                            examples=["undersampling"],
                                            description="Метод resampling: oversampling, undersampling, None")

@auto_generate_docstring
class EntryInferenceModel(BaseModel):
    """
    Класс для валидации входных данных EntryInferenceModel
    """
    model_config = ConfigDict(arbitrary_types_allowed=True)
    Prefix: Optional[StrictStr] = Field("",
                                        alias="prefix",
                                        examples=["exp1"],
                                        descripton="Префикс к названию модели")
    NameModel: StrictStr = Field(...,
                                 alias="name_model",
                                 examples=["efficientnet_b0_2024_10_02)"],
                                 description="Название файла .pt")
    NumClasses: Optional[StrictInt] = Field(2,
                                            alias="num_classes",
                                            examples=[2],
                                            description="Количество классов")
    ImageList: list[StrictStr] = Field(...,
                                       alias="image_path_list",
                                       examples=[["./images/image.jpg"]],
                                       description="Список путей к изображениям")
    SizeImg: Optional[tuple] = Field((64, 64),
                                     alias="size_img",
                                     examples=[(224, 224)],
                                     description="Размер изображения для инференса")
    PathWeights: Optional[StrictStr] = Field("./weights",
                                             alias="path_to_weights",
                                             examples=["./weights"],
                                             description="Путь к папке, где хранятся веса модели? Дефолтный путь ./weights")
    Plots: Optional[StrictBool] = Field(False,
                                        alias="plots",
                                        examples=[True],
                                        description="Строить рисунки? Да/Нет")
    SavePlots: Optional[StrictBool] = Field(True,
                                            alias="save_plots",
                                            examples=[True],
                                            description="Сохранять рисунки? Да/Нет")
    SavePathPlots: Optional[StrictStr] = Field("./result",
                                               alias="save_path_plots",
                                               examples=["./plot"],
                                               description="Если сохраняем рисунки, то куда? Дефолтный путь ./plot")
    UseDevice: Optional[StrictStr] = Field(None,
                                           alias="use_device",
                                           examples=["cuda"],
                                           description="Какое устройство использовать? cpu/cuda")
    GroundTruth: Optional[list[int]] = Field(None,
                                             alias="ground_truth",
                                             examples=[[1, 0]],
                                             description="Список ground truth меток для изображений")
    Classes: Optional[list[str]] = Field(None,
                                         alias="classes",
                                         examples=[["cat", "dog"]],
                                         description="Список названий классов")

class CatsVsDogsDatasetDownloader:
    def __init__(self, download_url, target_dir):
        self.download_url = download_url
        self.target_dir = target_dir
        self.dataset_zip = os.path.join(self.target_dir, 'cats_vs_dogs.zip')

    def download_dataset(self):
        os.makedirs(self.target_dir, exist_ok=True)
        response = requests.get(self.download_url, stream=True)
        total_size = int(response.headers.get('content-length', 0))
        
        with open(self.dataset_zip, 'wb') as file, tqdm(
            desc="Downloading CatsVsDogs Dataset",
            total=total_size,
            unit='B',
            unit_scale=True,
            unit_divisor=1024
        ) as bar:
            for data in response.iter_content(chunk_size=1024):
                file.write(data)
                bar.update(len(data))

    def extract_dataset(self):
        with zipfile.ZipFile(self.dataset_zip, 'r') as zip_ref:
            zip_ref.extractall(self.target_dir)

    def organize_dataset(self):
        # Определяем пути
        extracted_dir = os.path.join(self.target_dir, 'cats_and_dogs_filtered')
        cat_dir = os.path.join(self.target_dir, 'data', 'cats')
        dog_dir = os.path.join(self.target_dir, 'data', 'dogs')
    
        # Создаем целевые директории
        os.makedirs(cat_dir, exist_ok=True)
        os.makedirs(dog_dir, exist_ok=True)
    
        # Перенос файлов из train и validation
        for subset in ['train', 'validation']:
            subset_dir = os.path.join(extracted_dir, subset)
    
            for label in ['cats', 'dogs']:
                src_dir = os.path.join(subset_dir, label)
                target_dir = cat_dir if label == 'cats' else dog_dir
    
                for filename in os.listdir(src_dir):
                    src_file = os.path.join(src_dir, filename)
                    target_file = os.path.join(target_dir, filename)
    
                    # Проверяем, существует ли файл в целевой папке
                    if os.path.isfile(src_file) and not os.path.exists(target_file):
                        os.rename(src_file, target_file)
    
        # Удаляем временные файлы и папки
        os.remove(self.dataset_zip)
        shutil.rmtree(extracted_dir)  # Рекурсивно удаляем папку вместе с файлами

    def download_and_prepare(self):
        self.download_dataset()
        self.extract_dataset()
        self.organize_dataset()

# Скачивание и подготовка данных
dataset_url = "https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip"
target_directory = "./"

downloader = CatsVsDogsDatasetDownloader(dataset_url, target_directory)
downloader.download_and_prepare()

Downloading CatsVsDogs Dataset: 100%|█████████████████████████████████████████████| 65.4M/65.4M [00:03<00:00, 20.7MB/s]

class TrainDirCreator:

    def __init__(self,
                 image_dirs: list,
                 dest_dir: str,
                 ratio=(60, 20, 20)):
        self.dirs = image_dirs
        self.dest_dir = dest_dir
        self.ratio = ratio

        """
        ratio[0] = train
        ratio[1] = test
        ratio[2] = valid
        """

    def create_train_dirs(self):

        output_dir = self.dest_dir
        
        # Создание основной директории
        if not os.path.exists(output_dir):
            os.makedirs(output_dir)

        # Создание поддиректорий для train, test и validation
        for dataset_type in ["train_dataset", "test_dataset", "valid_dataset"]:
            dataset_path = os.path.join(output_dir, dataset_type)
            if not os.path.exists(dataset_path):
                os.makedirs(dataset_path)

        # Перемешивание и распределение изображений
        for image_dir in self.dirs:
            class_name = os.path.basename(image_dir)
            print(f"\nClass_name: {class_name}")
            image_list = os.listdir(image_dir)
            random.shuffle(image_list)
            total_images = len(image_list)
            train_count = int(total_images * self.ratio[0] / 100)
            print(f"Train_count: {train_count}")
            test_count = int(total_images * self.ratio[1] / 100)
            print(f"Test_count: {test_count}")
            valid_count = int(total_images * self.ratio[2] / 100)
            print(f"Valid_count: {valid_count}")

            # Перемешивание и копирование изображений в директории
            for i, image_name in enumerate(tqdm(image_list, desc="Shutil images", unit="image")):
                src_path = os.path.join(image_dir, image_name)
                if i < train_count:
                    dest_path = os.path.join(output_dir, "train_dataset", class_name, image_name)
                elif i < train_count + test_count:
                    dest_path = os.path.join(output_dir, "test_dataset", class_name, image_name)
                else:
                    dest_path = os.path.join(output_dir, "valid_dataset", class_name, image_name)

                # Создание директории для класса, если ее нет
                if not os.path.exists(os.path.dirname(dest_path)):
                    os.makedirs(os.path.dirname(dest_path))

                shutil.copy(src_path, dest_path)


def get_path_to_dir(path_to_data):
    list_dir = os.listdir(path_to_data)
    test_dir = os.path.join(path_to_data, list_dir[0])
    train_dir = os.path.join(path_to_data, list_dir[1])
    valid_dir = os.path.join(path_to_data, list_dir[2])
    return train_dir, test_dir, valid_dir

class FocalLoss(nn.Module):
    def __init__(self, alpha=None, gamma=2, reduction='mean'):
        super(FocalLoss, self).__init__()
        if isinstance(alpha, (list, torch.Tensor)):
            self.alpha = torch.tensor(alpha, dtype=torch.float32)
        else:
            self.alpha = alpha
        self.gamma = gamma
        self.reduction = reduction

    def forward(self, inputs, targets):
        ce_loss = F.cross_entropy(inputs, targets, reduction='none', weight=self.alpha)
        pt = torch.exp(-ce_loss)
        focal_loss = ((1 - pt) ** self.gamma) * ce_loss
        if self.reduction == 'mean':
            return focal_loss.mean()
        elif self.reduction == 'sum':
            return focal_loss.sum()
        else:  # 'none'
            return focal_loss

# Пример с двумя классами, вес для классов: [0.75, 0.25]
# focal_loss = FocalLoss(alpha=[0.75, 0.25], gamma=2, reduction='mean')

class CustomSubset(Subset):
    def __init__(self, dataset, indices):
        super().__init__(dataset, indices)
        self.classes = dataset.classes  # Сохраняем классы из оригинального датасета
        self.targets = [dataset.targets[i] for i in indices]  # Сохраняем targets

class GraduateModel:

    def __init__(self,
                 prefix: str = "",
                 name_model: str = "efficientnet_b0",
                 path_to_data: str = "./data",
                 path_to_weights: str = "./weights",
                 path_to_metrics_train: str = "./metrics_train",
                 path_to_metrics_test: str = "./metrics_test",
                 is_use_imagenet_weights: bool = True,
                 name_optimizer: str = "Adam",
                 num_epochs: int = 3,
                 batch_size: int = 1,
                 train_size_img: tuple = (224, 224),
                 ratio: tuple = (60, 20, 20),
                 is_gray: str = False,
                 class_percentages: dict = None,
                 name_loss: str = None,
                 is_use_class_weights: bool = False,
                 resampling_method: str = None,
                 use_device: str = None,
                 start_learning_rate: float = None,
                 pin_memory: bool = False,
                 num_workers: int = 0,
                 seed: int = 17):
        
        self.name_model = name_model
        self.name_model_user = f"{self.name_model}_{prefix}" if prefix != "" else self.name_model
        self.path_to_data = path_to_data
        directories_to_create = [path_to_weights, path_to_metrics_train, path_to_metrics_test]
        self.create_directories_if_not_exist(*directories_to_create)
        self.path_to_weights = os.path.join(path_to_weights, f"{self.name_model_user}.pt")
        self.path_to_metrics_train = os.path.join(path_to_metrics_train, f"{self.name_model_user}.pt")
        self.path_to_metrics_test = os.path.join(path_to_metrics_test, f"{self.name_model_user}.pt")
        self.num_epochs = num_epochs
        self.batch_size = batch_size
        self.size_img = train_size_img
        self.name_optimizer = name_optimizer
        self.size_img = train_size_img
        self.model = None
        self.train_loader = None
        self.valid_loader = None
        self.test_loader = None
        self.classes = None
        self.total_samples = None
        self.targets = None
        self.class_counts = None
        self.class_weights = None
        self.criterion = None
        self.scheduler = None
        self.imagenet = is_use_imagenet_weights
        self.is_gray = is_gray
        self.class_percentages = class_percentages
        self.name_loss = name_loss
        self.is_use_class_weights = is_use_class_weights
        self.resampling_method = resampling_method
        self.ratio = ratio
        self.use_device = use_device
        self.start_learning_rate = start_learning_rate
        self.pin_memory = pin_memory
        self.num_workers = num_workers
        self.seed = seed

        # Получение списка доступных моделей
        self.model_list = sorted(name for name in models.__dict__
                                 if name.islower() and not name.startswith("__")
                                 and name != "get_weight"
                                 and callable(models.__dict__[name]))

        # Перемещение модели на GPU, если CUDA доступен
        if self.use_device == None:
            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        elif self.use_device == "cuda":
            self.device = torch.device("cuda")
        elif self.use_device == "cpu":
            if self.pin_memory == True:
                raise Exception("pin_memory musn't be True with use_device cpu")
            self.device = torch.device("cpu")
        else:
            raise Exception("use_device must be cuda or cpu or None")

    @staticmethod
    def seed_everything(seed):
        random.seed(seed)
        os.environ["PYTHONHASHSEED"] = str(seed)
        np.random.seed(seed)
        torch.manual_seed(seed)
        torch.cuda.manual_seed(seed)
        torch.backends.cudnn.deterministic = True

    def graduate(self):
        # Фиксируем зерно
        self.seed_everything(self.seed)
        # Получаем трансформер
        self.get_transform()
        # Получаем генераторы обучения, валидации и теста
        self.get_loaders()
        # Загружаем модель
        self.get_model()
        # Получаем веса классов
        self.get_classes_weights()
        # Определяем оптимизатор, функцию потерь и планировщик
        self.get_opt_crit_sh()
        # Вывод архитектуры
        """summary(self.model,
                (3, self.size_img[0], self.size_img[1]),
                self.batch_size)"""
        # Выводим информацию
        print(self.__str__())
        # Обучаем
        self.train_model()
        # Тестируем
        self.evaluate_model()

    def __str__(self):

        return f"""
        
        ----------------------------------------------------------------------
        
        Выбранная модель: {self.name_model}
        Пользовательское название модели: {self.name_model_user}
        Выбранный оптимизатор: {self.name_optimizer}
        
        ----------------------------------------------------------------------
        
        """

    def create_directories_if_not_exist(self, *directories):
        for directory in directories:
            if not os.path.exists(directory):
                os.makedirs(directory)

    # Функция для показа изображения
    def image_show(self, img):
        img = img / 2 + 0.5  # unnormalize
        np_img = img.cpu().numpy()
        plt.imshow(np.transpose(np_img, (1, 2, 0)))
        plt.show()

    # Функция для сохранения модели
    def save_model(self):
        # Сохраняем модель
        torch.save({
            'epoch': self.num_epochs,
            'model_state_dict': self.model.state_dict(),
            'optimizer_state_dict': self.optimizer.state_dict()},
            f"{self.path_to_weights}")

    def save_metrics_train(self,
                           train_loss_values,
                           valid_loss_values,
                           f1_values):
        metrics = {
            'train_loss': train_loss_values,
            'valid_loss': valid_loss_values,
            'valid_f1': f1_values
        }
        # Сохранение метрик
        torch.save(metrics, self.path_to_metrics_train)

    def save_metrics_test(self,
                          f1,
                          class_acc_dir):
        metric = {
            'f1_value': f1,
            'Acc_dir': class_acc_dir
        }
        # Сохранение метрик
        torch.save(metric, self.path_to_metrics_test)

    def get_transform(self):
        if self.is_gray:
            self.transform = {
                "train": transforms.Compose([
                    transforms.Resize((self.size_img[0], self.size_img[1])),
                    transforms.RandomHorizontalFlip(),
                    transforms.RandomResizedCrop(size=(self.size_img[0], self.size_img[1])),
                    transforms.ToTensor()
                ]),
                "valid": transforms.Compose([
                    transforms.Resize((self.size_img[0], self.size_img[1])),
                    transforms.ToTensor()
                ])
            }
        else:
            self.transform = {
                "train": transforms.Compose([
                    transforms.Resize((self.size_img[0], self.size_img[1])),
                    transforms.AutoAugment(),
                    transforms.ToTensor(),
                    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
                ]),
                "valid": transforms.Compose([
                    transforms.Resize((self.size_img[0], self.size_img[1])),
                    transforms.ToTensor(),
                    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
                ])
            }

    @staticmethod
    def create_imbalanced_dataset(dataset, class_percentages):
    
        # Проверка входных данных
        if not hasattr(dataset, 'classes'):
            raise ValueError("Dataset must have a 'classes' attribute containing class names.")
    
        # Построим индексы для каждого класса
        class_to_indices = {class_name: [] for class_name in dataset.classes}
        for i, (_, label) in enumerate(dataset):
            class_name = dataset.classes[label]
            class_to_indices[class_name].append(i)
    
        # Отберем заданный процент для каждого класса
        selected_indices = []
        for class_name, percentage in class_percentages.items():
            if class_name not in class_to_indices:
                raise ValueError(f"Class '{class_name}' not found in the dataset.")
            if not (0 <= percentage <= 1):
                raise ValueError("Percentage values must be between 0 and 1.")
    
            class_indices = class_to_indices[class_name]
            selected_count = int(len(class_indices) * percentage)
            selected_indices.extend(random.sample(class_indices, selected_count))
    
        # Создаем поднабор данных
        return Subset(dataset, selected_indices)

    def get_classes_weights(self):
        # Получение количества примеров для каждого класса
        self.class_counts = np.bincount(self.targets)
        # Вычисление весов классов
        self.class_weights = torch.tensor([self.total_samples / count for count in self.class_counts],
                                          dtype=torch.float)
        self.class_weights = self.class_weights.to(self.device)

    # Функция для undersampling
    @staticmethod
    def create_undersampled_dataset(dataset):
        class_counts = Counter([label for _, label in dataset])
        min_class_count = min(class_counts.values())
        # Вычисление индексов для каждого класса
        class_indices = {cls: np.where(np.array(dataset.targets) == cls)[0] for cls in class_counts.keys()}
        # Обрезка индексов до минимального количества
        undersampled_indices = []
        for cls, indices in class_indices.items():
            undersampled_indices.extend(indices[:min_class_count])
        # Создание поднабора
        return CustomSubset(dataset, undersampled_indices)

    @staticmethod
    def create_oversampled_dataset(dataset):
        class_counts = Counter([label for _, label in dataset])
        max_class_count = max(class_counts.values())
        # Сохранение индексов для каждого класса
        class_indices = {cls: np.where(np.array(dataset.targets) == cls)[0] for cls in class_counts.keys()}
        oversampled_indices = []
        for cls, indices in class_indices.items():
            # Дублирование индексов, чтобы достичь максимального размера класса
            oversampled_indices.extend(
                np.random.choice(indices, size=max_class_count, replace=True)
            )
        # Создание поднабора
        return CustomSubset(dataset, oversampled_indices)

    # Функция для загрузки данных
    def get_loaders(self):
        # Список файлов с полными путями
        full_paths = [os.path.join(self.path_to_data, file) for file in os.listdir(self.path_to_data)]
        # Передача в TrainDirCreator
        train_dir_creator = TrainDirCreator(full_paths, "./dataset", self.ratio)
        train_dir_creator.create_train_dirs()
        # Получаем пути к директориям
        train_dir, test_dir, valid_dir = get_path_to_dir("./dataset")
        # Создание датасетов
        train_dataset = ImageFolder(train_dir, transform=self.transform["train"])
        test_dataset = ImageFolder(test_dir, transform=self.transform["valid"])
        valid_dataset = ImageFolder(valid_dir, transform=self.transform["valid"])

        if self.class_percentages is not None:
            # Создание несбалансированного датасета
            train_dataset = self.create_imbalanced_dataset(train_dataset, self.class_percentages)

        resampling_method_list = ["oversampling", "undersampling", None]

        if self.resampling_method not in resampling_method_list:
            raise Exception("resampling_method must be oversampling or undersampling")
        
        if self.resampling_method == "oversampling":
            train_dataset = self.create_oversampled_dataset(train_dataset)
        elif self.resampling_method == "undersampling":
            train_dataset = self.create_undersampled_dataset(train_dataset)
        
        # Создание загрузчиков данных
        self.train_loader = DataLoader(train_dataset, batch_size=self.batch_size, pin_memory=self.pin_memory,
                                       num_workers=self.num_workers, shuffle=True)
        self.test_loader = DataLoader(test_dataset, batch_size=self.batch_size, pin_memory=self.pin_memory,
                                      num_workers=self.num_workers, shuffle=False)
        self.valid_loader = DataLoader(valid_dataset, batch_size=self.batch_size, pin_memory=self.pin_memory,
                                       num_workers=self.num_workers, shuffle=False)
        # Список классов
        self.classes = train_dataset.classes
        self.total_samples = len(train_dataset)
        self.targets = train_dataset.targets

    def get_model(self):
        # Проверка доступности модели в torchvision
        if self.name_model in self.model_list:
            # Проверка доступности весов ImageNet
            if self.imagenet:
                try:
                    if self.name_model in ["inception_v3", "googlenet"]:
                        # Попытка загрузки модели с весами ImageNet
                        self.model = models.__dict__[self.name_model](init_weights=True)
                    else:
                        if self.name_model in ["regnet_y_128gf", "vit_h_14"]:
                            self.model = models.__dict__[self.name_model](weights="IMAGENET1K_SWAG_E2E_V1")
                        else:
                            self.model = models.__dict__[self.name_model](weights="IMAGENET1K_V1")
                except KeyError:
                    # Если веса ImageNet для данной модели недоступны, загрузка без весов
                    print(
                        f"Предобученные веса ImageNet для модели {self.name_model} недоступны."
                        f" Загрузка модели без предобученных весов.")
                    if self.name_model in ["inception_v3", "googlenet"]:
                        # Попытка загрузки модели с весами ImageNet
                        self.model = models.__dict__[self.name_model](init_weights=False)
                    else:
                        self.model = models.__dict__[self.name_model](weights=None)
            else:
                # Если не указано использование весов ImageNet, загрузить модель без них
                if self.name_model in ["inception_v3", "googlenet"]:
                    self.model = models.__dict__[self.name_model](init_weights=False)
                else:
                    self.model = models.__dict__[self.name_model](weights=None)

            try:
                name_without_numbers = re.sub(r'\d+', '', self.name_model)
                # Проверка доступности слоя classifier
                if hasattr(self.model, 'classifier'):
                    if name_without_numbers == "densenet":
                        num_features = self.model.classifier.in_features
                        self.model.classifier = nn.Linear(num_features, len(self.classes))
                    elif name_without_numbers == "squeezenet_":
                        num_features = 512
                        self.model.classifier[-1] = nn.Linear(num_features, len(self.classes))
                    else:
                        num_features = self.model.classifier[-1].in_features
                        self.model.classifier[-1] = nn.Linear(num_features, len(self.classes))
                elif hasattr(self.model, 'last_linear'):
                    num_features = self.model.last_linear.in_features
                    self.model.last_linear = nn.Linear(num_features, len(self.classes))
                elif hasattr(self.model, 'fc'):
                    num_features = self.model.fc.in_features
                    self.model.fc = nn.Linear(num_features, len(self.classes))
                elif hasattr(self.model, 'head'):
                    num_features = self.model.head.in_features
                    self.model.head = nn.Linear(num_features, len(self.classes))
                elif hasattr(self.model, "heads"):
                    num_features = self.model.heads[0].in_features
                    self.model.heads[0] = nn.Linear(num_features, len(self.classes))
                else:
                    print(f"Слой classifier не найден в модели. name_model:{self.name_model}")
            except Exception as ex:
                print(f"Exception: {ex}, name_model: {self.name_model}")

            # Перемещение модели на GPU и указание устройства
            self.model = self.model.to(self.device)
        else:
            print(f"Модель {self.name_model} не найдена в torchvision."
                  f"\nСписок доступных моделей: {self.model_list}")

    def get_opt_crit_sh(self):
        # Определение функции потерь с учетом весов классов
        available_losses = ["CrossEntropyLoss", "MSELoss", "L1Loss"]  # список доступных лоссов
        
        if self.name_loss == "FocalLoss":
            # Используем кастомный FocalLoss
            self.class_weights = self.class_weights if self.is_use_class_weights else None
            self.criterion = FocalLoss(alpha=self.class_weights, gamma=2)
        elif self.name_loss in available_losses:
            # Используем лоссы из torch.nn
            loss_class = getattr(nn, self.name_loss, None)
            if loss_class is None:
                raise ValueError(f"Loss function {self.name_loss} is not available in torch.nn")
            self.class_weights = self.class_weights if self.is_use_class_weights else None
            self.criterion = loss_class(weight=self.class_weights)
        else:
            raise ValueError(f"Loss function {self.name_loss} is not recognized")
    
        # Определение оптимизатора
        if self.start_learning_rate is not None:
            lr = self.start_learning_rate
        else:
            lr = 0.001
            
        self.optimizer = optim.__dict__[f"{self.name_optimizer}"](self.model.parameters(), lr=lr)
        
        # Создание планировщика LR
        # ReduceLROnPlateau уменьшает скорость обучения, когда метрика перестает уменьшаться
        self.scheduler = ReduceLROnPlateau(self.optimizer, mode='min', patience=2, verbose=True)

    # Функция для обучения модели с валидацией
    def train_model(self):

        train_loss_values = []
        valid_loss_values = []
        f1_values = []

        for epoch in range(self.num_epochs):
            self.model.train()
            running_loss = 0.0
            for inputs, labels in tqdm(self.train_loader, desc=f"Epoch {epoch + 1}/{self.num_epochs} (Train)",
                                       unit="sample"):
                inputs, labels = inputs.cuda(), labels.cuda()
                self.optimizer.zero_grad()
                outputs = self.model(inputs)
                loss = self.criterion(outputs, labels)
                loss.backward()
                self.optimizer.step()
                running_loss += loss.item() * inputs.size(0)

            # Вычисление loss на валидационном датасете и метрик
            self.model.eval()
            valid_loss = 0.0
            best_f1 = 0.0
            all_predictions = []
            all_labels = []
            with torch.no_grad():
                for inputs, labels in tqdm(self.valid_loader, desc=f"Epoch {epoch + 1}/{self.num_epochs} (Eval)",
                                           unit="sample"):
                    inputs, labels = inputs.cuda(), labels.cuda()
                    outputs = self.model(inputs)
                    loss = self.criterion(outputs, labels)
                    valid_loss += loss.item() * inputs.size(0)
                    _, predicted = torch.max(outputs, 1)
                    all_predictions.extend(predicted.cpu().numpy())
                    all_labels.extend(labels.cpu().numpy())

            epoch_loss = running_loss / len(self.train_loader.dataset)
            valid_loss = valid_loss / len(self.valid_loader.dataset)

            accuracy = accuracy_score(all_labels, all_predictions)
            precision = precision_score(all_labels, all_predictions, average='weighted')
            recall = recall_score(all_labels, all_predictions, average='weighted')
            f1 = f1_score(all_labels, all_predictions, average='weighted')

            # Сообщаем планировщику LR о текущей ошибке на валидационном наборе
            self.scheduler.step(valid_loss)

            # we want to save the model if the accuracy is the best
            if f1 > best_f1:
                self.save_model()
                best_f1 = f1

            # Добавление значений метрик в списки
            train_loss_values.append(epoch_loss)
            valid_loss_values.append(valid_loss)
            f1_values.append(f1)

            # Сохранение метрик
            self.save_metrics_train(train_loss_values,
                                    valid_loss_values,
                                    f1_values)

            print(f"\nEpoch {epoch + 1}/{self.num_epochs}, Training Loss: {epoch_loss}, Validation Loss: {valid_loss}")
            print(f"Accuracy: {accuracy}, Precision: {precision}, Recall: {recall}, F1-score: {f1}")

        print("Тренировка завершена!")

    # Функция для оценки модели на тестовом датасете
    def evaluate_model(self):
        self.model.eval()
        correct = 0
        total = 0
        all_predictions = []
        all_labels = []

        # Initialize variables to track correct predictions for each class
        class_correct = [0] * len(self.classes)
        class_total = [0] * len(self.classes)

        with torch.no_grad():
            for inputs, labels in tqdm(self.test_loader, desc="Test", unit="sample"):
                inputs, labels = inputs.cuda(), labels.cuda()
                outputs = self.model(inputs)
                _, predicted = torch.max(outputs, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()
                all_predictions.extend(predicted.cpu().numpy())
                all_labels.extend(labels.cpu().numpy())

                # Calculate class-wise correct predictions
                for i in range(len(labels)):
                    label = labels[i].item()
                    class_correct[label] += (predicted[i] == labels[i]).item()
                    class_total[label] += 1

        accuracy = correct / total
        print(f"Test Accuracy: {accuracy}")

        precision = precision_score(all_labels, all_predictions, average='weighted')
        recall = recall_score(all_labels, all_predictions, average='weighted')
        f1 = f1_score(all_labels, all_predictions, average='weighted')
        print(f"Precision: {precision}, Recall: {recall}, F1-score: {f1}")

        class_acc_dir = {}
        # Print accuracy for each class
        for i in range(len(self.classes)):
            class_acc = 100 * class_correct[i] / class_total[i] if class_total[i] != 0 else 0
            class_acc_dir[self.classes[i]] = class_acc
            print('Accuracy of %5s : %2d %%' % (self.classes[i], class_acc))

        self.save_metrics_test(f1,
                               class_acc_dir)

class InferenceModel:
    def __init__(self,
                 model_name: str,
                 num_classes: int,
                 path_to_weights: str,
                 image_paths: List[str],
                 prefix: str = "",
                 use_device: str = None,
                 classes: Optional[List[str]] = None,
                 plots: bool = False,
                 save_plots: bool = False,
                 plot_dir: str = './result',
                 size_img: tuple = (64, 64)):
        self.name_model = model_name
        self.path_to_weights = path_to_weights
        self.image_paths = image_paths
        self.classes = classes if classes is not None else []
        self.save_plots = save_plots
        self.plot_dir = plot_dir
        self.size_img = size_img
        self.use_device = use_device
        self.num_classes = num_classes
        self.plots = plots
        self.device = None
        self.prefix = prefix

        # Получение списка доступных моделей
        self.model_list = sorted(name for name in models.__dict__
                                 if name.islower() and not name.startswith("__")
                                 and name != "get_weight"
                                 and callable(models.__dict__[name]))

        # Перемещение модели на GPU, если CUDA доступен
        if self.use_device == None:
            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        elif self.use_device == "cuda":
            self.device = torch.device("cuda")
        elif self.use_device == "cpu":
            self.device = torch.device("cpu")
        else:
            raise Exception("use_device must be cuda or cpu or None")

    def get_model(self):
        # Проверка доступности модели в torchvision
        if self.name_model in self.model_list:
            if self.name_model in ["inception_v3", "googlenet"]:
                self.model = models.__dict__[self.name_model](init_weights=False)
            else:
                self.model = models.__dict__[self.name_model](weights=None)

            try:
                name_without_numbers = re.sub(r'\d+', '', self.name_model)
                # Проверка доступности слоя classifier
                if hasattr(self.model, 'classifier'):
                    if name_without_numbers == "densenet":
                        num_features = self.model.classifier.in_features
                        self.model.classifier = nn.Linear(num_features, self.num_classes)
                    elif name_without_numbers == "squeezenet_":
                        num_features = 512
                        self.model.classifier[-1] = nn.Linear(num_features, self.num_classes)
                    else:
                        num_features = self.model.classifier[-1].in_features
                        self.model.classifier[-1] = nn.Linear(num_features, self.num_classes)
                elif hasattr(self.model, 'last_linear'):
                    num_features = self.model.last_linear.in_features
                    self.model.last_linear = nn.Linear(num_features, self.num_classes)
                elif hasattr(self.model, 'fc'):
                    num_features = self.model.fc.in_features
                    self.model.fc = nn.Linear(num_features, self.num_classes)
                elif hasattr(self.model, 'head'):
                    num_features = self.model.head.in_features
                    self.model.head = nn.Linear(num_features, self.num_classes)
                elif hasattr(self.model, "heads"):
                    num_features = self.model.heads[0].in_features
                    self.model.heads[0] = nn.Linear(num_features, self.num_classes)
                else:
                    print(f"Слой classifier не найден в модели. name_model:{self.name_model}")
            except Exception as ex:
                print(f"Exception: {ex}, name_model: {self.name_model}")

            # Перемещение модели на GPU и указание устройства
            self.model = self.model.to(self.device)
            log.info("Модель инициализирована")
        else:
            print(f"Модель {self.name_model} не найдена в torchvision."
                  f"\nСписок доступных моделей: {self.model_list}")

    def load_model(self):
        if self.prefix != "":
            path = os.path.join(self.path_to_weights, f"{self.name_model}_{self.prefix}.pt")
        else:
            path = os.path.join(self.path_to_weights, f"{self.name_model}.pt")
        try:
            if self.name_model in models.__dict__:
                if os.path.exists(path):
                    state_dict = torch.load(path, map_location=self.device)['model_state_dict']
                    self.model.load_state_dict(state_dict)
                    log.info(f"Модель {self.name_model} успешно загружена с весами из {self.path_to_weights}.")
            else:
                log.warning(f"Модель {self.name_model} не найдена.")
        except Exception as e:
            log.exception(f"Ошибка при загрузке модели: {e}")

    def get_transform(self):
        return transforms.Compose([
            transforms.Resize((self.size_img[0], self.size_img[1])),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
        ])

    def predict(self):
        self.get_model()
        self.load_model()
        self.model.eval()
        predictions = []
        all_images = []

        with torch.no_grad():
            for image_path in tqdm(self.image_paths, desc="Classifying", unit="image"):
                try:
                    # Load image
                    image = Image.open(image_path).convert('RGB')
                    image = self.get_transform()(image).unsqueeze(0).to(self.device)

                    # Inference
                    output = self.model(image)
                    _, predicted_class = torch.max(output, 1)
                    predicted_label = predicted_class.item()

                    # Store prediction and image path
                    predictions.append(predicted_label)
                    all_images.append((image_path, predicted_label))

                    # If required, plot and save image
                    if self.save_plots:
                        self.plot_image(image_path, predicted_label)

                except Exception as e:
                    print(f"Ошибка при обработке изображения {image_path}: {e}")
                    predictions.append(None)

        print(f"predictions: {predictions}")

        return predictions, all_images

    def plot_image(self, image_path, predicted_label):
        image = Image.open(image_path)
        if self.plots is not None:
            plt.imshow(image)
        plt.title(f"Predicted: {self.classes[predicted_label] if self.classes else predicted_label}")
        plt.axis('off')
        if self.save_plots:
            if not os.path.exists(self.plot_dir):
                os.makedirs(self.plot_dir)
            plt.savefig(os.path.join(self.plot_dir, os.path.basename(image_path)), bbox_inches='tight')
        plt.show()

    def evaluate(self, predictions, ground_truth):
        # Calculate metrics
        precision = precision_score(ground_truth, predictions, average='weighted')
        recall = recall_score(ground_truth, predictions, average='weighted')
        f1 = f1_score(ground_truth, predictions, average='weighted')

        print(f"Precision: {precision}, Recall: {recall}, F1-score: {f1}")

        return precision, recall, f1

class MetricsVisualizer:
    def __init__(self,
                 prefix: str = "",
                 path_to_metrics_train: str = "./metrics_train",
                 path_to_metrics_test: str = "./metrics_test",
                 path_to_save_plots: str = None):

        self.prefix = prefix
        if path_to_save_plots:
            os.makedirs(path_to_save_plots, exist_ok=True)
        self.path_to_save_plots = path_to_save_plots if path_to_save_plots is not None else "./"
        self.metrics_train_dir = os.path.join(path_to_metrics_train)
        self.metrics_test_dir = os.path.join(path_to_metrics_test)
        self.train_loss_values = {}
        self.valid_loss_values = {}
        self.f1_values_valid = {}
        self.f1_values_test = {}
        self.class_acc_dir_values = {}

        # Инициализируем сохранение графиков
        self.load_train_metrics()
        self.load_test_metrics()
        self.plot_metrics()

    def _load_metrics(self, directory, files_dict, key_name):
        for file in os.listdir(directory):
            if file.endswith(".pt") and f"_{self.prefix}" in file:
                metrics = torch.load(os.path.join(directory, file))
                model_name = file.replace('.pt', '').replace(f'_{self.prefix}', '')
                files_dict[model_name] = metrics[key_name]

    def load_train_metrics(self):
        self._load_metrics(self.metrics_train_dir, self.train_loss_values, 'train_loss')
        self._load_metrics(self.metrics_train_dir, self.valid_loss_values, 'valid_loss')
        self._load_metrics(self.metrics_train_dir, self.f1_values_valid, 'valid_f1')

    def load_test_metrics(self):
        self._load_metrics(self.metrics_test_dir, self.f1_values_test, 'f1_value')
        self._load_metrics(self.metrics_test_dir, self.class_acc_dir_values, 'Acc_dir')

    def plot_metrics(self):
        fig, axs = plt.subplots(2, 2, figsize=(14, 10))

        # Сравнение категориальной кроссэнтропии для разных моделей на тренировке
        for model, train_loss in self.train_loss_values.items():
            axs[0, 0].plot(train_loss, label=model, linewidth=2)
        axs[0, 0].set_title('Функция потерь на тренировке', fontsize=12)
        axs[0, 0].set_xlabel('Эпоха')
        axs[0, 0].set_ylabel('Значение функции потерь', fontsize=12)

        # Вычисление адаптивных лимитов для оси Y
        all_values = [value for values in self.train_loss_values.values() for value in values]
        lower_limit = np.percentile(all_values, 0)  # нижний предел (например, 5-й перцентиль)
        upper_limit = np.percentile(all_values, 95)  # верхний предел (например, 95-й перцентиль)

        try:
            # Применение ограничений
            axs[0, 0].set_ylim(lower_limit, upper_limit)
        except Exception as ex:
            pass

        for model, valid_loss in self.valid_loss_values.items():
            axs[0, 1].plot(valid_loss, label=model, linewidth=2)
        axs[0, 1].set_title('Функция потерь на валидации', fontsize=12)
        axs[0, 1].set_xlabel('Эпоха')
        axs[0, 1].set_ylabel('Значение функции потерь', fontsize=12)

        # Вычисление адаптивных лимитов для оси Y
        all_values = [value for values in self.valid_loss_values.values() for value in values]
        lower_limit = np.percentile(all_values, 0)  # нижний предел (например, 5-й перцентиль)
        upper_limit = np.percentile(all_values, 95)  # верхний предел (например, 95-й перцентиль)
        
        try:
            # Применение ограничений
            axs[0, 1].set_ylim(lower_limit, upper_limit)
        except Exception as ex:
            axs[0, 1].set_ylim(0.4, 0.8)

        for model, f1_valid in self.f1_values_valid.items():
            axs[1, 0].plot(f1_valid, label=model, linewidth=2)
        axs[1, 0].set_title('F1-мера на валидации', fontsize=12)
        axs[1, 0].set_xlabel('Эпоха')
        axs[1, 0].set_ylabel('Значение метрики F1-мера', fontsize=12)

        for model, f1_score in self.f1_values_test.items():
            bar = axs[1, 1].bar(model, f1_score, label=model)
            axs[1, 1].text(bar.patches[0].get_x() + bar.patches[0].get_width() / 2.,
                           bar.patches[0].get_height() + 0.02,
                           f'{f1_score:.2f}',
                           ha='center', va='bottom', rotation=90, fontsize=8, color='black')

        axs[1, 1].set_title('F1-мера на тесте', fontsize=12)
        axs[1, 1].set_xlabel('Название модели')
        axs[1, 1].set_ylabel('Значение метрики F1-мера', fontsize=12)
        plt.setp(axs[1, 1].get_xticklabels(), rotation=90, fontsize=6)

        # Добавление общей легенды
        handles, labels = axs[0, 0].get_legend_handles_labels()
        fig.legend(handles, labels, loc='center right', fontsize=8, frameon=False)

        # Обрезаем графики, чтобы освободить место для легенды
        plt.subplots_adjust(left=0.1, right=0.8, top=0.9, bottom=0.1)
        path = os.path.join(self.path_to_save_plots, f"PlotsMetrics_{self.prefix}.png")
        plt.savefig(path, dpi=500)
        plt.show()

        plt.figure(figsize=(8, 8))
        class_names = list(self.class_acc_dir_values[list(self.class_acc_dir_values.keys())[0]].keys())
        num_classes = len(class_names)

        for i, class_name in enumerate(class_names):
            plt.subplot(num_classes, 1, i + 1)
            for model, class_acc_dir in self.class_acc_dir_values.items():
                acc = class_acc_dir.get(class_name, 0)
                bar = plt.bar(model, acc, label=model)
                percentage = acc
                plt.text(bar[0].get_x() + bar[0].get_width() / 2.,
                         bar[0].get_height() - bar[0].get_height() * 0.3,
                         f'{percentage:.2f}%', ha='center', va='bottom', rotation=90, fontsize=6, color='white')

            plt.xlabel('Название модели')
            plt.ylabel('Accuracy')
            plt.title(f'Accuracy для класса: {class_name}')
            plt.xticks(rotation=90, fontsize=8)
            plt.subplots_adjust(hspace=0.5)

        plt.tight_layout()
        path = os.path.join(self.path_to_save_plots, f"AccuracyForClass_{self.prefix}.png")
        plt.savefig(path, dpi=500)
        plt.show()

@dataclass
class GraduateModelPipeline:
    entry: EntryGraduateModel

    def __post_init__(self):
        pass

    def graduate(self):

        prefix = self.entry.Prefix
        models = self.entry.Models
        name_optimizers = self.entry.NameOptimizers
        is_use_imagenet_weights = self.entry.UseImageNetWeights
        ratio = self.entry.Ratio
        path_to_data = self.entry.PathData
        path_to_weights = self.entry.PathWeights
        use_device = self.entry.UseDevice
        name_loss = self.entry.NameLoss
        is_gray = self.entry.IsGray
        class_percentages = self.entry.ClassPercentages
        is_use_class_weights = self.entry.UseClassWeights
        resampling_method = self.entry.ResamplingMethod
        start_learning_rate = self.entry.StartLerningRate
        train_size_img = self.entry.SizeImg
        batch_size = self.entry.BatchSize
        num_workers = self.entry.NumWorkers
        pin_memory = self.entry.PinMemory
        num_epochs = self.entry.NumEpochs
        seed = self.entry.Seed

        path_to_metrics_train = self.entry.PathMetricsTrain
        path_to_metrics_test = self.entry.PathMetricsTest
        path_to_save_plots = self.entry.PathSavePlots
    
        for index, name_model in enumerate(models):

            try:
                train = GraduateModel(
                              prefix=prefix,
                              name_model=name_model,
                              path_to_data=path_to_data,
                              path_to_weights=path_to_weights,
                              path_to_metrics_train=path_to_metrics_train,
                              path_to_metrics_test=path_to_metrics_test,
                              is_use_imagenet_weights=is_use_imagenet_weights,
                              name_optimizer=name_optimizers[index],
                              name_loss=name_loss,
                              num_epochs=num_epochs,
                              batch_size=batch_size,
                              train_size_img=train_size_img,
                              is_gray=is_gray,
                              class_percentages=class_percentages,
                              is_use_class_weights=is_use_class_weights,
                              resampling_method=resampling_method,
                              use_device=use_device,
                              num_workers=num_workers,
                              pin_memory=pin_memory,
                              seed=seed)
                train.graduate()
            except Exception as ex:
                log.exception("GraduateModel\n", exc_info=ex)

        # Построение графиков
        try:
            metrics_visualizer = MetricsVisualizer(prefix=prefix,
                                                   path_to_metrics_train=path_to_metrics_train,
                                                   path_to_metrics_test=path_to_metrics_test,
                                                   path_to_save_plots=path_to_save_plots)
        except Exception as ex:
            log.exception("MetricsVisualiser\n", exc_info=ex)

@dataclass
class InferenceModelPipeline:
    entry: EntryInferenceModel

    def __post_init__(self):
        pass

    def inference(self):

        prefix = self.entry.Prefix
        name_model = self.entry.NameModel
        num_classes = self.entry.NumClasses
        path_to_weights = self.entry.PathWeights
        image_path_list = self.entry.ImageList
        use_device = self.entry.UseDevice
        classes = self.entry.Classes
        plots = self.entry.Plots
        save_plots = self.entry.SavePlots
        save_path_plots = self.entry.SavePathPlots
        ground_truth = self.entry.GroundTruth
        size_img = self.entry.SizeImg
        
        try:
            inference_model = InferenceModel(
                          prefix=prefix,
                          model_name=name_model,
                          num_classes=num_classes,
                          path_to_weights=path_to_weights,
                          image_paths=image_path_list,
                          use_device=use_device,
                          size_img=size_img,
                          classes=classes,
                          plots=plots,
                          save_plots=save_plots,
                          plot_dir=save_path_plots)
            predictions, all_images = inference_model.predict()
            log.info(f"Predictions: {predictions}")
            if ground_truth is not None:
                precision, recall, f1 = inference_model.evaluate(predictions, ground_truth)
                log.info(f"Precision: {precision}, Recall: {recall}, F1: {f1}")
            return predictions, all_images
        except Exception as ex:
            log.exception("InferenceModel\n", exc_info=ex)

exclude_model = ["get_weight", "convnext_base", "convnext_large", "convnext_small",
                 "densenet161", "efficientnet_b5", "efficientnet_b6", "efficientnet_b7",
                 "efficientnet_v2_l", "efficientnet_v2_m", "regnet_x_8gf", "regnet_x_32gf",
                 "regnet_y_32gf", "regnet_y_128gf", "resnext101_32x8d", "vit_h_14", "vit_l_16",
                 "vit_l_32", "googlenet", "inception_v3", "squeezenet1_0", "squeezenet1_1"]

optimizer_list = ["SGD", "SGD", "SGD", "SGD", "SGD", "AdamW", "AdamW", "AdamW", "AdamW",
                  "AdamW", "AdamW", "AdamW", "AdamW", "AdamW", "AdamW", "AdamW", "AdamW", "AdamW",
                  "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD",
                  "SGD", "SGD", "SGD", "SGD", "SGD", "AdamW", "AdamW", "AdamW", "AdamW", "SGD", "SGD", "SGD",
                  "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD", "SGD"]


# Получение списка доступных моделей
model_list = sorted(name for name in models.__dict__
                    if name.islower() and not name.startswith("__")
                    and name not in exclude_model
                    and callable(models.__dict__[name]))
print(model_list)

['alexnet', 'convnext_tiny', 'densenet121', 'densenet169', 'densenet201', 'efficientnet_b0', 'efficientnet_b1', 'efficientnet_b2', 'efficientnet_b3', 'efficientnet_b4', 'efficientnet_v2_s', 'mnasnet0_5', 'mnasnet0_75', 'mnasnet1_0', 'mnasnet1_3', 'mobilenet_v2', 'mobilenet_v3_large', 'mobilenet_v3_small', 'regnet_x_16gf', 'regnet_x_1_6gf', 'regnet_x_3_2gf', 'regnet_x_400mf', 'regnet_x_800mf', 'regnet_y_16gf', 'regnet_y_1_6gf', 'regnet_y_3_2gf', 'regnet_y_400mf', 'regnet_y_800mf', 'regnet_y_8gf', 'resnet101', 'resnet152', 'resnet18', 'resnet34', 'resnet50', 'resnext101_64x4d', 'resnext50_32x4d', 'shufflenet_v2_x0_5', 'shufflenet_v2_x1_0', 'shufflenet_v2_x1_5', 'shufflenet_v2_x2_0', 'swin_b', 'swin_s', 'swin_t', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn', 'vgg19', 'vgg19_bn', 'vit_b_16', 'vit_b_32', 'wide_resnet101_2', 'wide_resnet50_2']

graduate_pipeline = validate_with_pydantic(EntryGraduateModel)(GraduateModelPipeline)(
    entry = {
        "prefix": "Exp1",
        "models": model_list,
        "name_optimizers": optimizer_list,
        "name_loss": "CrossEntropyLoss",
        "ratio":(70, 15, 15),
        "size_img": (64, 64),
        "batch_size": 25,
        "num_epochs": 10,
        "class_percentage": {"cats": 0.3, "dogs": 1.0}
    }
)

graduate_pipeline.graduate()

Class_name: cats
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1858.24image/s]

Class_name: dogs
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1755.94image/s]

        
        ----------------------------------------------------------------------
        
        Выбранная модель: alexnet
        Пользовательское название модели: alexnet_Exp1
        Выбранный оптимизатор: SGD
        
        ----------------------------------------------------------------------

Epoch 1/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:07<00:00, 16.42sample/s]
Epoch 1/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 24.70sample/s]

Epoch 1/10, Training Loss: 0.6933255725482133, Validation Loss: 0.6931324764496862
Accuracy: 0.5033898305084745, Precision: 0.25340132145935074, Recall: 0.5033898305084745, F1-score: 0.3371066057745591

Epoch 2/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:08<00:00, 14.38sample/s]
Epoch 2/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 23.69sample/s]

Epoch 2/10, Training Loss: 0.6931735874039413, Validation Loss: 0.6931255032113717
Accuracy: 0.5033898305084745, Precision: 0.25340132145935074, Recall: 0.5033898305084745, F1-score: 0.3371066057745591

Epoch 3/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:07<00:00, 14.97sample/s]
Epoch 3/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 24.12sample/s]

ipd.display(ipd.Image(filename="./plot/PlotsMetrics_Exp1.png"))
ipd.display(ipd.Image(filename="./plot/AccuracyForClass_Exp1.png"))

graduate_pipeline = validate_with_pydantic(EntryGraduateModel)(GraduateModelPipeline)(
    entry = {
        "prefix": "Exp2",
        "models": model_list,
        "name_optimizers": optimizer_list,
        "name_loss": "CrossEntropyLoss",
        "ratio":(70, 15, 15),
        "size_img": (64, 64),
        "batch_size": 25,
        "num_epochs": 10,
        "class_percentage": {"cats": 0.3, "dogs": 1.0},
        "resampling_method": "undersampling"
    }
)

graduate_pipeline.graduate()

Class_name: cats
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1884.68image/s]

Class_name: dogs
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1831.12image/s]

        
        ----------------------------------------------------------------------
        
        Выбранная модель: alexnet
        Пользовательское название модели: alexnet_Exp2
        Выбранный оптимизатор: SGD
        
        ----------------------------------------------------------------------

Epoch 1/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:06<00:00, 17.13sample/s]
Epoch 1/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:03<00:00, 23.10sample/s]

Epoch 1/10, Training Loss: 0.6931814674249629, Validation Loss: 0.693174991567256
Accuracy: 0.4966101694915254, Precision: 0.2466216604424016, Recall: 0.4966101694915254, F1-score: 0.329573679866403

Epoch 2/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:07<00:00, 15.49sample/s]
Epoch 2/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 25.60sample/s]

Epoch 2/10, Training Loss: 0.6932309001581776, Validation Loss: 0.6931709773459677
Accuracy: 0.4966101694915254, Precision: 0.2466216604424016, Recall: 0.4966101694915254, F1-score: 0.329573679866403

Epoch 3/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:07<00:00, 15.35sample/s]
Epoch 3/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 25.13sample/s]

ipd.display(ipd.Image(filename="./plot/PlotsMetrics_Exp2.png"))
ipd.display(ipd.Image(filename="./plot/AccuracyForClass_Exp2.png"))

graduate_pipeline = validate_with_pydantic(EntryGraduateModel)(GraduateModelPipeline)(
    entry = {
        "prefix": "Exp3",
        "models": model_list,
        "name_optimizers": optimizer_list,
        "name_loss": "CrossEntropyLoss",
        "ratio":(70, 15, 15),
        "size_img": (64, 64),
        "batch_size": 25,
        "num_epochs": 10,
        "class_percentage": {"cats": 0.3, "dogs": 1.0},
        "resampling_method": "oversampling"
    }
)

graduate_pipeline.graduate()

Class_name: cats
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1581.45image/s]

Class_name: dogs
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1795.42image/s]

        
        ----------------------------------------------------------------------
        
        Выбранная модель: alexnet
        Пользовательское название модели: alexnet_Exp3
        Выбранный оптимизатор: SGD
        
        ----------------------------------------------------------------------

Epoch 1/10 (Train): 100%|████████████████████████████████████████████████████████| 118/118 [00:06<00:00, 17.00sample/s]
Epoch 1/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 25.49sample/s]

Epoch 1/10, Training Loss: 0.6932017837007487, Validation Loss: 0.6931827024551435
Accuracy: 0.4966101694915254, Precision: 0.2466216604424016, Recall: 0.4966101694915254, F1-score: 0.329573679866403

Epoch 2/10 (Train): 100%|████████████████████████████████████████████████████████| 118/118 [00:08<00:00, 14.70sample/s]
Epoch 2/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 24.54sample/s]

Epoch 2/10, Training Loss: 0.6932622427330878, Validation Loss: 0.6931674884537519
Accuracy: 0.4966101694915254, Precision: 0.2466216604424016, Recall: 0.4966101694915254, F1-score: 0.329573679866403

Epoch 3/10 (Train): 100%|████████████████████████████████████████████████████████| 118/118 [00:08<00:00, 14.60sample/s]
Epoch 3/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 24.02sample/s]

ipd.display(ipd.Image(filename="./plot/PlotsMetrics_Exp3.png"))
ipd.display(ipd.Image(filename="./plot/AccuracyForClass_Exp3.png"))

graduate_pipeline = validate_with_pydantic(EntryGraduateModel)(GraduateModelPipeline)(
    entry = {
        "prefix": "Exp4",
        "models": model_list,
        "name_optimizers": optimizer_list,
        "name_loss": "FocalLoss",
        "ratio":(70, 15, 15),
        "size_img": (64, 64),
        "batch_size": 25,
        "num_epochs": 10,
        "class_percentage": {"cats": 0.3, "dogs": 1.0},
        "is_use_class_weights": True
    }
)

graduate_pipeline.graduate()

Class_name: cats
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1872.98image/s]

Class_name: dogs
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1863.21image/s]

        
        ----------------------------------------------------------------------
        
        Выбранная модель: alexnet
        Пользовательское название модели: alexnet_Exp4
        Выбранный оптимизатор: SGD
        
        ----------------------------------------------------------------------

Epoch 1/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:06<00:00, 16.75sample/s]
Epoch 1/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 24.38sample/s]

Epoch 1/10, Training Loss: 0.7801671731014461, Validation Loss: 0.7797609333601375
Accuracy: 0.5033898305084745, Precision: 0.25340132145935074, Recall: 0.5033898305084745, F1-score: 0.3371066057745591

Epoch 2/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:06<00:00, 17.15sample/s]
Epoch 2/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 25.73sample/s]

Epoch 2/10, Training Loss: 0.7797855815714234, Validation Loss: 0.7797391980381335
Accuracy: 0.5033898305084745, Precision: 0.25340132145935074, Recall: 0.5033898305084745, F1-score: 0.3371066057745591

Epoch 3/10 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:07<00:00, 15.16sample/s]
Epoch 3/10 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:02<00:00, 23.95sample/s]

ipd.display(ipd.Image(filename="./plot/PlotsMetrics_Exp4.png"))
ipd.display(ipd.Image(filename="./plot/AccuracyForClass_Exp4.png"))

graduate_pipeline = validate_with_pydantic(EntryGraduateModel)(GraduateModelPipeline)(
    entry = {
        "prefix": "CatsVsDogs",
        "models": ["shufflenet_v2_x2_0"],
        "name_optimizers": ["AdamW"],
        "name_loss": "CrossEntropyLoss",
        "ratio":(70, 15, 15),
        "size_img": (64, 64),
        "batch_size": 25,
        "num_epochs": 50,
        "class_percentage": {"cats": 0.3, "dogs": 1.0},
        "is_use_class_weights": True,
        "resampling_method": "undersampling"
    }
)

graduate_pipeline.graduate()

Class_name: cats
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1672.74image/s]

Class_name: dogs
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1744.52image/s]

        
        ----------------------------------------------------------------------
        
        Выбранная модель: shufflenet_v2_x2_0
        Пользовательское название модели: shufflenet_v2_x2_0_CatsVsDogs
        Выбранный оптимизатор: AdamW
        
        ----------------------------------------------------------------------

Epoch 1/50 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:12<00:00,  9.71sample/s]
Epoch 1/50 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:03<00:00, 20.91sample/s]

Epoch 1/50, Training Loss: 0.7818373362837788, Validation Loss: 0.6694855243809479
Accuracy: 0.5694915254237288, Precision: 0.6259043600036523, Recall: 0.5694915254237288, F1-score: 0.5121810434321343

Epoch 2/50 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:11<00:00,  9.80sample/s]
Epoch 2/50 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:03<00:00, 21.13sample/s]

Epoch 2/50, Training Loss: 0.6892301994295874, Validation Loss: 0.5868471929077375
Accuracy: 0.6949152542372882, Precision: 0.70726470729754, Recall: 0.6949152542372882, F1-score: 0.6907329032979306

Epoch 3/50 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:11<00:00,  9.84sample/s]
Epoch 3/50 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:03<00:00, 20.94sample/s]

ipd.display(ipd.Image(filename="./plot/PlotsMetrics_CatsVsDogs.png"))
ipd.display(ipd.Image(filename="./plot/AccuracyForClass_CatsVsDogs.png"))

graduate_pipeline = validate_with_pydantic(EntryGraduateModel)(GraduateModelPipeline)(
    entry = {
        "prefix": "CatsVsDogs_ImageNet",
        "models": ["shufflenet_v2_x2_0"],
        "name_optimizers": ["AdamW"],
        "name_loss": "CrossEntropyLoss",
        "ratio":(70, 15, 15),
        "size_img": (64, 64),
        "batch_size": 25,
        "num_epochs": 50,
        "class_percentage": {"cats": 0.3, "dogs": 1.0},
        "is_use_class_weights": True,
        "is_use_imagenet_weights": True,
        "resampling_method": "undersampling"
    }
)

graduate_pipeline.graduate()

Class_name: cats
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1824.14image/s]

Class_name: dogs
Train_count: 900
Test_count: 300
Valid_count: 300

Shutil images: 100%|██████████████████████████████████████████████████████████| 1500/1500 [00:00<00:00, 1858.90image/s]
Downloading: "https://download.pytorch.org/models/shufflenetv2_x2_0-8be3c8ee.pth" to C:\Users\NightMare/.cache\torch\hub\checkpoints\shufflenetv2_x2_0-8be3c8ee.pth
100%|█████████████████████████████████████████████████████████████████████████████| 28.4M/28.4M [00:29<00:00, 1.01MB/s]

        
        ----------------------------------------------------------------------
        
        Выбранная модель: shufflenet_v2_x2_0
        Пользовательское название модели: shufflenet_v2_x2_0_CatsVsDogs_ImageNet
        Выбранный оптимизатор: AdamW
        
        ----------------------------------------------------------------------

Epoch 1/50 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:11<00:00,  9.79sample/s]
Epoch 1/50 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:03<00:00, 21.24sample/s]

Epoch 1/50, Training Loss: 0.5413268122476401, Validation Loss: 32.838974695000275
Accuracy: 0.8864406779661017, Precision: 0.8864420413427745, Recall: 0.8864406779661017, F1-score: 0.8864410767023491

Epoch 2/50 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:12<00:00,  9.71sample/s]
Epoch 2/50 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:03<00:00, 20.55sample/s]

Epoch 2/50, Training Loss: 0.41914324744050857, Validation Loss: 11.47977851377537
Accuracy: 0.9209039548022598, Precision: 0.9211509725788821, Recall: 0.9209039548022598, F1-score: 0.9208850631425942

Epoch 3/50 (Train): 100%|████████████████████████████████████████████████████████| 117/117 [00:12<00:00,  9.63sample/s]
Epoch 3/50 (Eval): 100%|███████████████████████████████████████████████████████████| 71/71 [00:03<00:00, 21.75sample/s]

ipd.display(ipd.Image(filename="./plot/PlotsMetrics_CatsVsDogs_ImageNet.png"))
ipd.display(ipd.Image(filename="./plot/AccuracyForClass_CatsVsDogs_ImageNet.png"))

imgs = [f"./images/{file}" for file in os.listdir("./images")]
print(imgs)

inference_pipeline = validate_with_pydantic(EntryInferenceModel)(InferenceModelPipeline)(
    entry = {
        "prefix": "CatsVsDogs",
        "name_model": "shufflenet_v2_x2_0",
        "image_path_list": imgs,
        "classes": ["cat", "dog"],
        "ground_truth": [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
        "size_img": (64, 64)
    }
)

['./images/cat.jpg', './images/cat1.jpg', './images/cat2.jpg', './images/cat3.jpg', './images/cat4.jpg', './images/cat4.png', './images/dog.png', './images/dog1.jpg', './images/dog2.jpg', './images/dog3.jpg', './images/dog4.jpg']

inference_pipeline.inference()

17:43:51-470640 INFO     Модель инициализирована

17:43:51-716303 INFO     Модель shufflenet_v2_x2_0 успешно загружена с весами из ./weights.

Classifying:   0%|                                                                           | 0/11 [00:00<?, ?image/s]

Classifying:   9%|██████                                                             | 1/11 [00:00<00:03,  3.07image/s]

Classifying:  18%|████████████▏                                                      | 2/11 [00:00<00:02,  3.81image/s]

Classifying:  27%|██████████████████▎                                                | 3/11 [00:00<00:01,  4.44image/s]

imgs = [f"./images/{file}" for file in os.listdir("./images")]
print(imgs)

inference_pipeline = validate_with_pydantic(EntryInferenceModel)(InferenceModelPipeline)(
    entry = {
        "prefix": "CatsVsDogs_ImageNet",
        "name_model": "shufflenet_v2_x2_0",
        "image_path_list": imgs,
        "classes": ["cat", "dog"],
        "ground_truth": [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
        "size_img": (64, 64)
    }
)

['./images/cat.jpg', './images/cat1.jpg', './images/cat2.jpg', './images/cat3.jpg', './images/cat4.jpg', './images/cat4.png', './images/dog.png', './images/dog1.jpg', './images/dog2.jpg', './images/dog3.jpg', './images/dog4.jpg']

inference_pipeline.inference()

17:44:03-568895 INFO     Модель инициализирована

17:44:03-700660 INFO     Модель shufflenet_v2_x2_0 успешно загружена с весами из ./weights.

Classifying:   0%|                                                                           | 0/11 [00:00<?, ?image/s]

Classifying:   9%|██████                                                             | 1/11 [00:00<00:03,  3.25image/s]

Classifying:  18%|████████████▏                                                      | 2/11 [00:00<00:02,  4.30image/s]

Classifying:  27%|██████████████████▎                                                | 3/11 [00:00<00:01,  5.19image/s]

Домашняя работа №1 по дисциплине «МОВС: Компьютерное зрение»¶

ANSI коды для цветов текста¶

Шаблоны markdown¶

Установка библиотек¶

Подготовка к написанию кода¶

Импорт библиотек¶

Дополнительные настройки¶

Кастомный setup_logging¶

Валидация входящих данных для каждого класса¶

validate_with_pydantic¶

auto_generate_docstring¶

EntryGraduateModel¶

EntryInferenceModel¶

Загрузка и предобработка данных¶

Загрузка и распаковка набор данных CatVsDogs¶

Формирование датасета для обучения TrainDirCreator¶

Обучение моделей¶

FocalLoss¶

CustomSubset¶

GraduateModel¶

Инференс моделью¶

InferenceModel¶

Визуализация графиков обучения¶

MetricsVisualizer¶

Пайплайн¶

GraduateModelPipeline¶

InferenceModelPipeline¶

Список моделей и оптимизаторов¶

Эксперименты¶

Exp1 / Диcбаланс классов + кроссэнтропия¶

Exp2 / Диcбаланс классов + кроссэнтропия + undersampling¶

Exp3 / Диcбаланс классов + кроссэнтропия + oversampling¶

Exp4 / Диcбаланс классов + focal_loss + class_weights¶

Длительное обучение + лучший эксп¶

Длительное обучение + лучший эксп + ImageNet¶

Инференс¶

shufflenet_v2_x2_0¶

shufflenet_v2_x2_0 + ImageNet¶

Выводы¶